Summary

Translates the objects (LiveObjects) UTS unit specs into runnable Kotlin tests in the uts
module, using the uts-to-kotlin skill. Of the 15 objects/unit specs, 10 are translated
(181 tests) and 5 are blocked by missing internal implementation (documented, not silently
skipped).

This is translate-only: every test compiles (./gradlew :uts:compileTestKotlin is green). Most
run only once the LiveObjects engine (OBJECT_SYNC processing + RealtimeObject.get()) lands; the
message-layer and value-type construction tests run today.

Base branch: feature/liveobjects-uts-tests.

What's included

10 translated spec files — 181 @Test methods

Each test carries a verbatim @UTS objects/unit/… tag tracing it to the source spec point. All files
follow the uts conventions (no star imports, runTest, shared helpers.kt).

Deviations — uts/src/test/kotlin/io/ably/lib/uts/deviations.md
Per-test divergences where ably-java (a typed SDK) differs from the spec's dynamic API, e.g.:

• wrong-type Instance cast throws IllegalStateException rather than ErrorInfo 92007;
• value()/size() partitioned off the wrong-typed view (not expressible);
• compact() unimplemented → compactJson() used;
• invalid-input cases the type system rejects at compile time;
• internal wire-message-shape assertions adapted to observable public effects.

Blocked specs — uts/src/test/kotlin/io/ably/lib/uts/private_deviations.md
The 5 specs that could not be translated, with the reasons and a recommended path forward.

The 5 blocked specs

live_counter.md, live_map.md, object_id.md, objects_pool.md, parent_references.md assert on the
internal CRDT graph (live nodes + applyOperation, siteTimeserials, the ObjectsPool, object-id
generation, parent references). Two blockers:

1. Not implemented yet (primary). :liveobjects currently ships only the public view layer; the
   CRDT engine these specs test does not exist (ObjectsPool, generateObjectId, applyOperation, … =
   0 references). There is nothing to assert against.
2. Cross-module internal visibility (secondary). Once implemented, those symbols will be Kotlin
   internal and unreachable from the :uts test module at compile time.

private_deviations.md lays out the realistic options for when the engine lands — the recommended one
(to keep tests under uts/unit) is a java-test-fixtures bridge in :liveobjects exposing a small
public inspection surface; the lowest-ceremony alternative is authoring them in :liveobjects/src/test.

Notes / caveats

• Translate-only: tests are not run in CI here; the gate is compilation. deviations.md entries that
  document SDK behaviour become live once the engine is implemented.
• A few not-expressible cases (inputs the typed signatures reject at compile time) are intentionally
  documented no-op test bodies, paired with a // DEVIATION note + deviations.md entry.
• LiveCounterApiTest / LiveMapApiTest contain a few wire-shape assertions read reflectively /
  via observable round-trip; these are unverified until the SDK publish path lands (flagged in the code).

How it was produced

Driven by the uts-to-kotlin skill (per-spec: read the objects mapping doc + infra, translate, compile
once for the whole module, review against the spec). The bulk batch was fanned out with a multi-agent
workflow (one agent per spec, parallel), then compiled and fixed centrally.

Testing

./gradlew :uts:compileTestKotlin   # BUILD SUCCESSFUL — all 10 classes compile

Update — integration & proxy tiers added

Extends this PR beyond the unit tier: the direct-sandbox integration and proxy integration objects specs are now translated. Still translate-only (compiles; runs once the LiveObjects engine lands and against the sandbox). With these, all non-blocked objects specs across all three tiers are translated — only the 5 internal-graph unit specs remain blocked (above).

Integration tier — direct sandbox (integration/standard/liveobjects/)

Real-sandbox happy path: connect → sync → create/mutate via PathObject → verify propagation to a second client; no fault injection. Each case runs once per protocol variant (JSON + msgpack) via a useBinaryProtocol @ParameterizedTest.

Clients hit the nonprod sandbox (sandbox.realtime.ably-nonprod.net via ProxyManager.sandboxRealtimeHost); a throwaway app is provisioned with SandboxApp in @BeforeAll/@AfterAll.

Proxy tier — sandbox + fault injection (integration/proxy/liveobjects/)

Routes the SDK through the programmable uts-proxy to inject transport faults (disconnect mid-OBJECT_SYNC, delayed sync, server-initiated DETACHED, channel ERROR→FAILED). JSON-only (the proxy inspects only text frames).

Other changes

• Integration REST fixture helper — integration/standard/liveobjects/helpers.kt: provisionObjectsViaRest(...) plus op/value builders, the ably-java translation of standard_test_pool.md's provision_objects_via_rest. Built to the V2 objects REST contract (POST /channels/{ch}/object, payload-key ops, no {messages} envelope), targeting the nonprod sandbox host via restHost. Used by RTPO15's rest-provisioned-data-sync case; compiles against :java only (public AblyRest).
• junit-jupiter-params added to uts/build.gradle.kts — enables the protocol-variant @ParameterizedTest in the integration tier (version managed by the JUnit BOM already on the test classpath).
• objects-mapping.md §14 — documents the integration REST-helper mapping in the uts-to-kotlin skill reference.

Related

The V2 + nonprod-host alignment of the UTS source spec is tracked upstream in ably/specification#497 (the provision_objects_via_rest host/shape and the objects integration client endpoints).

Testing

./gradlew :uts:compileTestKotlin   # BUILD SUCCESSFUL — unit + integration + proxy all compile